/**
 * 视频类型控制器
 * 处理视频类型相关的CRUD操作
 */
const { VideoType } = require('../models');
const { Op } = require('sequelize');

class VideoTypeController {
  /**
   * 获取所有视频类型
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   * @returns {Promise<void>}
   */
  static async getAllVideoTypes(req, res) {
    try {
      const videoTypes = await VideoType.findAll({
        attributes: ['type_id', 'name', 'description', 'created_at', 'updated_at'],
        order: [['type_id', 'ASC']]
      });
      
      return res.status(200).json({
        code: 200,
        message: '获取视频类型列表成功',
        data: videoTypes
      });
    } catch (error) {
      console.error('获取视频类型列表失败:', error);
      return res.status(500).json({
        code: 500,
        message: '服务器错误，获取视频类型列表失败',
        error: error.message
      });
    }
  }

  /**
   * 根据ID获取视频类型详情
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   * @returns {Promise<void>}
   */
  static async getVideoTypeById(req, res) {
    try {
      const { type_id } = req.params;
      
      const videoType = await VideoType.findByPk(type_id, {
        attributes: ['type_id', 'name', 'description', 'created_at', 'updated_at']
      });
      
      if (!videoType) {
        return res.status(404).json({
          code: 404,
          message: '视频类型不存在'
        });
      }
      
      return res.status(200).json({
        code: 200,
        message: '获取视频类型详情成功',
        data: videoType
      });
    } catch (error) {
      console.error('获取视频类型详情失败:', error);
      return res.status(500).json({
        code: 500,
        message: '服务器错误，获取视频类型详情失败',
        error: error.message
      });
    }
  }

  /**
   * 创建新的视频类型
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   * @returns {Promise<void>}
   */
  static async createVideoType(req, res) {
    try {
      const { name, description } = req.body;
      
      // 验证必填字段
      if (!name || name.trim() === '') {
        return res.status(400).json({
          code: 400,
          message: '视频类型名称不能为空'
        });
      }
      
      // 检查名称是否已存在
      const existingType = await VideoType.findOne({
        where: { name: { [Op.like]: name } }
      });
      
      if (existingType) {
        return res.status(400).json({
          code: 400,
          message: '视频类型名称已存在'
        });
      }
      
      // 创建新的视频类型
      const newVideoType = await VideoType.create({
        name: name.trim(),
        description: description || null
      });
      
      return res.status(201).json({
        code: 201,
        message: '创建视频类型成功',
        data: {
          type_id: newVideoType.type_id,
          name: newVideoType.name,
          description: newVideoType.description,
          created_at: newVideoType.created_at,
          updated_at: newVideoType.updated_at
        }
      });
    } catch (error) {
      console.error('创建视频类型失败:', error);
      return res.status(500).json({
        code: 500,
        message: '服务器错误，创建视频类型失败',
        error: error.message
      });
    }
  }

  /**
   * 更新视频类型信息
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   * @returns {Promise<void>}
   */
  static async updateVideoType(req, res) {
    try {
      const { type_id } = req.params;
      const { name, description } = req.body;
      
      // 查找视频类型
      const videoType = await VideoType.findByPk(type_id);
      
      if (!videoType) {
        return res.status(404).json({
          code: 404,
          message: '视频类型不存在'
        });
      }
      
      // 如果要更新名称，检查新名称是否已存在
      if (name && name.trim() !== videoType.name) {
        const existingType = await VideoType.findOne({
          where: {
            name: { [Op.like]: name.trim() },
            type_id: { [Op.ne]: type_id }
          }
        });
        
        if (existingType) {
          return res.status(400).json({
            code: 400,
            message: '视频类型名称已存在'
          });
        }
      }
      
      // 更新视频类型信息
      const updatedData = {};
      if (name !== undefined) updatedData.name = name.trim();
      if (description !== undefined) updatedData.description = description;
      
      await videoType.update(updatedData);
      
      return res.status(200).json({
        code: 200,
        message: '更新视频类型成功',
        data: {
          type_id: videoType.type_id,
          name: videoType.name,
          description: videoType.description,
          created_at: videoType.created_at,
          updated_at: videoType.updated_at
        }
      });
    } catch (error) {
      console.error('更新视频类型失败:', error);
      return res.status(500).json({
        code: 500,
        message: '服务器错误，更新视频类型失败',
        error: error.message
      });
    }
  }

  /**
   * 删除视频类型
   * @param {Object} req - Express请求对象
   * @param {Object} res - Express响应对象
   * @returns {Promise<void>}
   */
  static async deleteVideoType(req, res) {
    try {
      const { type_id } = req.params;
      
      // 查找视频类型
      const videoType = await VideoType.findByPk(type_id);
      
      if (!videoType) {
        return res.status(404).json({
          code: 404,
          message: '视频类型不存在'
        });
      }
      
      // 检查是否有视频使用该类型
      const { Video } = require('../models');
      const videoCount = await Video.count({
        where: { video_type_id: type_id }
      });
      
      if (videoCount > 0) {
        return res.status(400).json({
          code: 400,
          message: `该视频类型正在被${videoCount}个视频使用，无法删除`
        });
      }
      
      // 删除视频类型
      await videoType.destroy();
      
      return res.status(200).json({
        code: 200,
        message: '删除视频类型成功',
        data: {
          type_id: Number(type_id)
        }
      });
    } catch (error) {
      console.error('删除视频类型失败:', error);
      return res.status(500).json({
        code: 500,
        message: '服务器错误，删除视频类型失败',
        error: error.message
      });
    }
  }
}

module.exports = VideoTypeController;